package juanca.mole;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.util.Calendar;
import java.util.HashMap;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;

import ClasesExtras.GetIpAddress;
import ClasesExtras.ManejadorCampos;
import ClasesExtras.handlerAlertMessage;
import ClasesExtras.handlerDb;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.DatePickerDialog;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.app.TimePickerDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.WindowManager;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.TimePicker;
import android.widget.Toast;

import com.savagelook.android.JsonHelper;

public class NuevoProceso extends Activity {

	private int fAno;
	private int fMes;
	private int fDia;
	private int hMinuto;
	private int hHora;
	private String NumLoteNueP;
	private String productoNueP;
	private String idEmpleado;
	private String passwEmpleado;
	private String idOperarioEmpleado;
	private double TempInicio;

	private String fechaUsuario;
	private String tiempoUsuario;
	private String fechaSistema;
	private String tiempoSistema;

	private Spinner mostrarProducto;
	private Button btnComenzaNueP;
	private HashMap<String, Integer> productoId;

	public ProgressDialog progressDialog;
	public String NombreProductoNueP;
	public String time;
	public String date;

	public static final int DATE_DIALOG_ID = 0;
	public static final int TIME_DIALOG_ID = 1;
	public static final String STRING_EMPTY = "";
	private String URL_PRODUCTOS;
	private String URL_VALIDAR_USUARIO;
	private String URL_REGISTRO_NUEVO_PROCESO;
	private static final String CNV = "cnv";
	private static final String PNV = "pnv";
	private static final String no_permiso = "no_permiso";

	private EditText etNumLoteNueP;
	private EditText etTempIni;
	private ManejadorCampos manejador;
	private handlerAlertMessage manejadorMensajes;
	private Activity activity;
	private NuevoProceso self = this;

	/**
	 * @return the idOperarioEmpleado
	 */
	public String getIdOperarioEmpleado() {
		return idOperarioEmpleado;
	}

	/**
	 * @param idOperarioEmpleado
	 *            the idOperarioEmpleado to set
	 */
	public void setIdOperarioEmpleado(String idOperarioEmpleado) {
		this.idOperarioEmpleado = idOperarioEmpleado;
	}

	/**
	 * @return the passwEmpleado
	 */
	public String getPasswEmpleado() {
		return passwEmpleado;
	}

	/**
	 * @param passwEmpleado
	 *            the passwEmpleado to set
	 */
	public void setPasswEmpleado(String passwEmpleado) {
		this.passwEmpleado = passwEmpleado;
	}

	/**
	 * @return the idEmpleado
	 */
	public String getIdEmpleado() {
		return idEmpleado;
	}

	/**
	 * @param idEmpleado
	 *            the idEmpleado to set
	 */
	public void setIdEmpleado(String idEmpleado) {
		this.idEmpleado = idEmpleado;
	}

	/**
	 * @return the productoNueP
	 */
	public String getProductoNueP() {
		return productoNueP;
	}

	/**
	 * @param productoNueP
	 *            the productoNueP to set
	 */
	public void setProductoNueP(String productoNueP) {
		this.productoNueP = productoNueP;
	}

	/**
	 * @return the tiempoSistema
	 */
	public String getTiempoSistema() {
		return tiempoSistema;
	}

	/**
	 * @param tiempoSistema
	 *            the tiempoSistema to set
	 */
	public void setTiempoSistema(String tiempoSistema) {
		this.tiempoSistema = tiempoSistema;
	}

	/**
	 * @return the fechaSistema
	 */
	public String getFechaSistema() {
		return fechaSistema;
	}

	/**
	 * @param fechaSistema
	 *            the fechaSistema to set
	 */
	public void setFechaSistema(String fechaSistema) {
		this.fechaSistema = fechaSistema;
	}

	/**
	 * @return the tiempoUsuario
	 */
	public String getTiempoUsuario() {
		return tiempoUsuario;
	}

	/**
	 * @param tiempoUsuario
	 *            the tiempoUsuario to set
	 */
	public void setTiempoUsuario(String tiempoUsuario) {
		this.tiempoUsuario = tiempoUsuario;
	}

	/**
	 * @return the fechaUsuario
	 */
	public String getFechaUsuario() {
		return fechaUsuario;
	}

	/**
	 * @param fechaUsuario
	 *            the fechaUsuario to set
	 */
	public void setFechaUsuario(String fechaUsuario) {
		this.fechaUsuario = fechaUsuario;
	}

	/**
	 * @return the tempInicio
	 */
	public double getTempInicio() {
		return TempInicio;
	}

	/**
	 * @param tempInicio
	 *            the tempInicio to set
	 */
	public void setTempInicio(double tempInicio) {
		TempInicio = tempInicio;
	}

	/**
	 * @return the numLoteNueP
	 */
	public String getNumLoteNueP() {
		return NumLoteNueP;
	}

	/**
	 * @param numLoteNueP
	 *            the numLoteNueP to set
	 */
	public void setNumLoteNueP(String numLoteNueP) {
		NumLoteNueP = numLoteNueP;
	}

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.layout_nuevo_proceso);
		getWindow().setSoftInputMode(
				WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

		btnComenzaNueP = (Button) findViewById(R.id.btnComenzaNueP);
		etNumLoteNueP = (EditText) findViewById(R.id.etNumLoteNueP);
		etTempIni = (EditText) findViewById(R.id.etTempIni);
		mostrarProducto = (Spinner) findViewById(R.id.spiProdNueP);
		manejadorMensajes = new handlerAlertMessage();
		manejador = new ManejadorCampos();
		activity = this;

	}

	@Override
	protected void onStart() {
		super.onStart();
		GetIpAddress direccion = new GetIpAddress(this);

		if (direccion.getDireccion() != null) {
			URL_PRODUCTOS = direccion.getDireccion() + "/productos.json";
			URL_VALIDAR_USUARIO = direccion.getDireccion() + "/validar.json";
			URL_REGISTRO_NUEVO_PROCESO = direccion.getDireccion()
					+ "/procesos.json";
			final ProgressDialog pd = ProgressDialog.show(this, null,
					this.getString(R.string.PbMsjCargando), true, true);
			new Thread(new Runnable() {
				@Override
				public void run() {
					self.mostrarProducto(URL_PRODUCTOS);
					Log.e("NuevoProceso", "carga productos");
					pd.dismiss();

				}
			}).start();
		} else {
			new AlertDialog.Builder(this)
					.setIcon(android.R.drawable.ic_dialog_alert)
					.setTitle(R.string.tituloAlerta)
					.setMessage(R.string.msjErSinDireccion)
					.setPositiveButton(R.string.btnAceptar,
							new DialogInterface.OnClickListener() {// un
								// listener que al pulsar, cierre la
								// aplicacion
								@Override
								public void onClick(DialogInterface dialog,
										int which) {
									// Salir
									Intent intent = new Intent();
									intent.setClass(activity, Etapas.class);
									startActivity(intent);
								}
							}).show();
		}
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		// Handle item selection
		switch (item.getItemId()) {
		case R.id.menu_settings:
			Intent intent = new Intent();
			intent.setClass(this, Etapas.class);
			startActivity(intent);
			return true;
		default:
			return super.onOptionsItemSelected(item);
		}
	}

	@SuppressWarnings("deprecation")
	public void FechaNueP(View v) {
		final Calendar c = Calendar.getInstance();
		fAno = c.get(Calendar.YEAR);
		fMes = c.get(Calendar.MONTH);
		fDia = c.get(Calendar.DAY_OF_MONTH);
		showDialog(DATE_DIALOG_ID);
	}

	@SuppressWarnings("deprecation")
	public void HoraNueP(View v) {
		final Calendar c = Calendar.getInstance();
		hHora = c.get(Calendar.HOUR_OF_DAY);
		hMinuto = c.get(Calendar.MINUTE);
		showDialog(TIME_DIALOG_ID);

	}

	@SuppressLint("SimpleDateFormat")
	private TimePickerDialog.OnTimeSetListener showtime = new TimePickerDialog.OnTimeSetListener() {

		@SuppressLint("SimpleDateFormat")
		@Override
		public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
			hHora = hourOfDay;
			hMinuto = minute;

			Context context = getApplicationContext();
			CharSequence text = new StringBuilder().append(hHora).append(":")
					.append(hMinuto);
			int duration = Toast.LENGTH_SHORT;

			Toast toast = Toast.makeText(context, text, duration);
			toast.show();
			time = (hHora + ":" + hMinuto).toString();
			setTiempoUsuario(time);

		}
	};

	private DatePickerDialog.OnDateSetListener showdate = new DatePickerDialog.OnDateSetListener() {

		@SuppressLint("SimpleDateFormat")
		@Override
		public void onDateSet(DatePicker view, int year, int monthOfYear,
				int dayOfMonth) {
			fAno = year;
			fMes = monthOfYear + 1;
			fDia = dayOfMonth;

			Context context = getApplicationContext();
			CharSequence text = new StringBuilder().append(fDia).append("-")
					.append(fMes).append("-").append(fAno);
			int duration = Toast.LENGTH_SHORT;

			Toast toast = Toast.makeText(context, text, duration);
			toast.show();

			date = (fDia + "-" + fMes + "-" + fAno + "-").toString();

			setFechaUsuario(date);

		}
	};

	@Override
	protected Dialog onCreateDialog(int id) {
		switch (id) {
		case TIME_DIALOG_ID:
			return new TimePickerDialog(this, showtime, hHora, hMinuto, true);

		case DATE_DIALOG_ID:
			return new DatePickerDialog(this, showdate, fAno, fMes, fDia);
		}
		return null;
	}

	// metodo que captura la fecha y la hora del sistema
	@SuppressLint("SimpleDateFormat")
	public void fechaHoraSistema() {
		final Calendar c = Calendar.getInstance();
		int ano = c.get(Calendar.YEAR);
		int mes = c.get(Calendar.MONTH) + 1;
		int dia = c.get(Calendar.DAY_OF_MONTH);
		int hora = c.get(Calendar.HOUR_OF_DAY);
		int minuto = c.get(Calendar.MINUTE);

		date = (dia + "-" + mes + "-" + ano + "-").toString();
		time = (hora + ":" + minuto).toString();

		this.setFechaSistema(date);
		this.setTiempoSistema(time);

	}

	/* Spinner de productos */
	public void mostrarProducto(String urlProductos) {

		productoId = new HashMap<String, Integer>();

		JSONObject productosJson = new JSONObject();
		JSONArray productosJsonArray;
		try {
			productosJsonArray = JsonHelper.getJsonArrayFromUrl(urlProductos);

			final ArrayAdapter<String> Lista_Productos = new ArrayAdapter<String>(
					this, android.R.layout.simple_spinner_item);

			if (productosJsonArray.length() != 0) {
				for (int j = 0; j < productosJsonArray.length(); j++) {
					productosJson = productosJsonArray.getJSONObject(j);
					Lista_Productos.add(productosJson.getString("nombre"));
					NombreProductoNueP = productosJson.getString("nombre");
					productoId.put(NombreProductoNueP,
							Integer.parseInt(productosJson.getString("id")));

				}

				runOnUiThread(new Runnable() {
					public void run() {
						Lista_Productos
								.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
						mostrarProducto.setAdapter(Lista_Productos);
					}
				});
			} else {

				/*
				 * hilo que muestra el mensaje de error de conexion al cargar
				 * los datos
				 */
				runOnUiThread(new Runnable() {
					public void run() {

						btnComenzaNueP.setEnabled(false);

						AlertDialog.Builder mensajeEmergente = new AlertDialog.Builder(
								activity);
						mensajeEmergente
								.setIcon(android.R.drawable.ic_dialog_alert);
						mensajeEmergente.setTitle(R.string.tituloError);
						mensajeEmergente
								.setMessage(R.string.msjERNoHayProductos);
						mensajeEmergente.setNeutralButton(R.string.btnAceptar,
								new DialogInterface.OnClickListener() {

									public void onClick(DialogInterface dialog,
											int which) {
										NuevoProceso.this.finish();

									}
								});

						mensajeEmergente.create();
						mensajeEmergente.show();
					}
				});
			}

		} catch (MalformedURLException e) {
			/*
			 * hilo que muestra el mensaje de error de conexion al cargar los
			 * datos
			 */
			runOnUiThread(new Runnable() {
				public void run() {

					AlertDialog.Builder mensajeEmergente = new AlertDialog.Builder(
							activity);
					mensajeEmergente.setTitle(R.string.tituloError);
					mensajeEmergente.setMessage(R.string.msjERConexionCargar);
					mensajeEmergente.setNeutralButton(R.string.btnAceptar,
							new DialogInterface.OnClickListener() {

								public void onClick(DialogInterface dialog,
										int which) {
									NuevoProceso.this.finish();

								}
							});

					mensajeEmergente.create();
					mensajeEmergente.show();
				}
			});
		} catch (JSONException e) {
			/*
			 * hilo que muestra el mensaje de error de conexion al cargar los
			 * datos
			 */
			runOnUiThread(new Runnable() {
				public void run() {

					AlertDialog.Builder mensajeEmergente = new AlertDialog.Builder(
							activity);
					mensajeEmergente.setTitle(R.string.tituloError);
					mensajeEmergente.setMessage(R.string.msjERConexionCargar);
					mensajeEmergente.setNeutralButton(R.string.btnAceptar,
							new DialogInterface.OnClickListener() {

								public void onClick(DialogInterface dialog,
										int which) {
									NuevoProceso.this.finish();

								}
							});

					mensajeEmergente.create();
					mensajeEmergente.show();
				}
			});
		} catch (IOException e) {
			/*
			 * hilo que muestra el mensaje de error de conexion al cargar los
			 * datos
			 */
			runOnUiThread(new Runnable() {
				public void run() {

					AlertDialog.Builder mensajeEmergente = new AlertDialog.Builder(
							activity);
					mensajeEmergente.setTitle(R.string.tituloError);
					mensajeEmergente.setMessage(R.string.msjERConexionCargar);
					mensajeEmergente.setNeutralButton(R.string.btnAceptar,
							new DialogInterface.OnClickListener() {

								public void onClick(DialogInterface dialog,
										int which) {
									NuevoProceso.this.finish();

								}
							});

					mensajeEmergente.create();
					mensajeEmergente.show();
				}
			});
		}

		catch (NullPointerException e) {
			/*
			 * hilo que muestra el mensaje de error de conexion al cargar los
			 * datos
			 */
			runOnUiThread(new Runnable() {
				public void run() {

					AlertDialog.Builder mensajeEmergente = new AlertDialog.Builder(
							activity);
					mensajeEmergente.setTitle(R.string.tituloError);
					mensajeEmergente.setMessage(R.string.msjERConexionCargar);
					mensajeEmergente.setNeutralButton(R.string.btnAceptar,
							new DialogInterface.OnClickListener() {

								public void onClick(DialogInterface dialog,
										int which) {
									NuevoProceso.this.finish();

								}
							});

					mensajeEmergente.create();
					mensajeEmergente.show();
				}
			});
		}

	}

	// metodo para comezar el proceso
	public void comenzarProceso(View v) {
		int numLote = manejador.validarLote(etNumLoteNueP);
		int tempInicio = manejador.validarPh(etTempIni);

		if (numLote != 0) {
			switch (numLote) {
			case 20:
				manejadorMensajes.alertMessageOneButton(activity,
						R.string.tituloAlerta, R.string.msjNumLote,
						R.string.btnAceptar);
				break;
			case 21:
				manejadorMensajes.alertMessageOneButton(activity,
						R.string.tituloAlerta, R.string.msjNumLoteEspec,
						R.string.btnAceptar);
				break;
			case 22:
				manejadorMensajes.alertMessageOneButton(activity,
						R.string.tituloAlerta, R.string.msjNumLoteEspac,
						R.string.btnAceptar);
				break;

			}
		} else {
			if (tempInicio != 0) {
				switch (tempInicio) {
				case 17:
					manejadorMensajes.alertMessageOneButton(activity,
							R.string.tituloAlerta, R.string.msjTempIni,
							R.string.btnAceptar);
					break;
				}
			} else {

				this.validar();

			}
		}

	}

	// metodo que crear una ventana emergente para registrar el codigo y
	// contrasena
	public void mensajeRegistro() {

		AlertDialog.Builder mensajeEmergente = new AlertDialog.Builder(this);
		LayoutInflater inflater = this.getLayoutInflater();
		final View Inflator = inflater
				.inflate(R.layout.registro_empleado, null);
		final EditText ed1 = (EditText) Inflator
				.findViewById(R.id.etIdeEmpleado);
		final EditText ed2 = (EditText) Inflator
				.findViewById(R.id.etPasswEmpleado);
		mensajeEmergente.setTitle(R.string.msjValidarRegistro);
		mensajeEmergente.setView(Inflator);
		mensajeEmergente.setPositiveButton(R.string.btnRegistrar,
				new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						setIdEmpleado(ed1.getText().toString());
						setPasswEmpleado(ed2.getText().toString());

						if (!self.getIdEmpleado().equals(STRING_EMPTY)
								|| !self.getPasswEmpleado()
										.equals(STRING_EMPTY)) {

							progressDialog = new ProgressDialog(self);
							progressDialog.setMessage(self
									.getString(R.string.PbMsjCreandoProceso));
							progressDialog.setCancelable(true);
							progressDialog.show();

							new Thread(new Runnable() {
								@Override
								public void run() {
									self.validarUsuario();
									Log.e("NuevoProceso",
											"entra validar usuario");

								}
							}).start();

						} else {
							// msj hace falta password o id
							manejadorMensajes.alertMessageOneButton(activity,
									R.string.tituloAlerta,
									R.string.msjIdPasswInvali,
									R.string.btnAceptar);
						}

					}
				});
		mensajeEmergente.setNegativeButton(R.string.btnCancelar,
				new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {

					}
				});
		mensajeEmergente.create();
		mensajeEmergente.show();

	}

	// valida si los campos de usuario estan vacios
	public void validarUsuario() {

		String ced = this.getIdEmpleado();
		String pass = this.getPasswEmpleado();
		HttpClient httpClient = new DefaultHttpClient();
		HttpPost post = new HttpPost(URL_VALIDAR_USUARIO);// operarios
		post.setHeader("content-type", "application/json");

		try {

			// Construimos el objeto en formato JSON
			JSONObject dato = new JSONObject();
			dato.put("cedula", ced);// cedula del operario
			dato.put("password", pass);// contrasena del operario
			dato.put("formulario", "f_proceso");// permisos

			StringEntity entity = new StringEntity(dato.toString());
			post.setEntity(entity);
			HttpResponse resp = httpClient.execute(post);
			this.setIdOperarioEmpleado(EntityUtils.toString(resp.getEntity()));

			if (this.getIdOperarioEmpleado().equals(CNV)) {
				runOnUiThread(new Runnable() {
					public void run() {
						progressDialog.dismiss();
						manejadorMensajes.alertMessageOneButton(activity,
								R.string.tituloAlerta,
								R.string.msjCedulaIncorrecta,
								R.string.btnAceptar);

					}
				});

			} else {
				if (this.getIdOperarioEmpleado().equals(PNV)) {
					runOnUiThread(new Runnable() {
						public void run() {
							progressDialog.dismiss();
							manejadorMensajes.alertMessageOneButton(activity,
									R.string.tituloAlerta,
									R.string.msjPasswordIncorrecta,
									R.string.btnAceptar);

						}
					});

				} else {

					if (this.getIdOperarioEmpleado().equals(no_permiso)) {
						runOnUiThread(new Runnable() {
							public void run() {
								progressDialog.dismiss();
								manejadorMensajes.alertMessageOneButton(
										activity, R.string.tituloAlerta,
										R.string.msjSinPermisos,
										R.string.btnAceptar);

							}
						});
					} else {

						new Thread(new Runnable() {
							@Override
							public void run() {
								self.envioBaseDatos();
								Log.e("NuevoProceso", "entra envio basedatos");

							}
						}).start();
					}

				}

			}

		} catch (Exception ex) {
			runOnUiThread(new Runnable() {
				public void run() {

					progressDialog.dismiss();
					manejadorMensajes.alertMessageOneButton(activity,
							R.string.tituloError, R.string.msjERvalidarUsuario,
							R.string.btnAceptar);

				}
			});

		}

	}

	public void validar() {
		this.fechaHoraSistema();
		if (this.getFechaSistema() != null && this.getTiempoSistema() != null) {
			if (this.getFechaUsuario() != null) {
				if (this.getTiempoUsuario() != null) {

					this.setNumLoteNueP(etNumLoteNueP.getText().toString());
					this.setTempInicio(Double.parseDouble(this.etTempIni
							.getText().toString()));
					this.setProductoNueP(mostrarProducto.getSelectedItem()
							.toString());

					this.mensajeRegistro();

				} else {
					// seleccione la hora
					manejadorMensajes.alertMessageOneButton(activity,
							R.string.tituloAlerta, R.string.msjSelecHora,
							R.string.btnAceptar);
				}
			} else {
				// seleccione la fecha
				manejadorMensajes.alertMessageOneButton(activity,
						R.string.tituloAlerta, R.string.msjSelecFecha,
						R.string.btnAceptar);
			}
		}
	}

	/* metodo que envia los datos al servidor */
	public void envioBaseDatos() {

		HttpClient httpClient = new DefaultHttpClient();
		// URL del servidor para guardar los datos de lavadoMaquina
		HttpPost post = new HttpPost(URL_REGISTRO_NUEVO_PROCESO);
		String Estado = "iniciado";

		try {
			// Construimos el objeto cliente en formato JSON
			JSONObject dato = new JSONObject();

			// se almacenan los datos capturados por los campos de texto en
			// el objeto JSON para enviarlo al servidor.
			dato.put("empleado_id",
					Integer.parseInt(this.getIdOperarioEmpleado()));
			dato.put("fecha_usuario", this.getFechaUsuario());
			dato.put("fecha_sistema", this.getFechaSistema());
			dato.put("hora_usuario", this.getTiempoUsuario());
			dato.put("hora_sistema", this.getTiempoSistema());
			dato.put("no_lote", this.getNumLoteNueP());
			dato.put("temp_ini", this.getTempInicio());
			dato.put("producto_id", productoId.get(this.getProductoNueP()));
			dato.put("estado", Estado);

			StringEntity entity = new StringEntity(dato.toString());
			post.setHeader("Content-Type", "application/json; chartset=UTF-8");
			post.setHeader("Accept", "application/json");
			post.setEntity(entity);
			HttpResponse resp = httpClient.execute(post);

			// retorna un Json como respuesta
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					resp.getEntity().getContent(), "UTF-8"));
			String json = reader.readLine();
			JSONTokener tokener = new JSONTokener(json);
			JSONArray finalResult = new JSONArray(tokener);

			Log.e("NuevoProceso1", finalResult.toString());

			if (finalResult.getJSONObject(0).getString("estado").equals("true")) {

				String idProceso = finalResult.getJSONObject(0).getString("id");
				String idProducto = finalResult.getJSONObject(0).getString(
						"producto");
				Log.i("EnviarLote", "idProceso= " + idProceso);
				Log.i("EnviarLote", "idProducto= " + idProducto);

				// ingreso de datos a la base de datos locales
				handlerDb dataBase = new handlerDb(this);
				dataBase.abrir();

				if (dataBase.leer("id_proceso") == null) {
					dataBase.registrar(this.getNumLoteNueP(),
							Integer.parseInt(this.getIdOperarioEmpleado()),
							Integer.parseInt(idProceso),
							Integer.parseInt(idProducto),
							this.getProductoNueP());
					dataBase.registrarTabla4("new");
					dataBase.registrarTabla5("false");
					dataBase.registrarTabla6("false");
					Log.i("NuevoProceso", "registra un nuevo proceso: "
							+ idProceso);
				} else {
					int result = dataBase.eliminar();
					int resulTb4 = dataBase.eliminarTabla4();
					int resulTb5 = dataBase.eliminarTabla5();
					int resulTb6 = dataBase.eliminarTabla6();
					if (result >= 0) {
						dataBase.registrar(this.getNumLoteNueP(),
								Integer.parseInt(this.getIdOperarioEmpleado()),
								Integer.parseInt(idProceso),
								Integer.parseInt(idProducto),
								this.getProductoNueP());
						if (resulTb4 >= 0) {
							dataBase.registrarTabla4("new");
						}
						if (resulTb5 >= 0) {
							dataBase.registrarTabla5("false");
						}
						if (resulTb6 >= 0) {
							dataBase.registrarTabla6("false");
						}

						Log.i("NuevoProceso",
								"elimina el dato y crea uno nuevo");
					}
				}

				dataBase.cerrar();

				Log.i("NuevoProceso", "el servidor me retorna true");
				this.setIdOperarioEmpleado(null);
				this.setNumLoteNueP(null);
				this.setTempInicio(0);
				this.setFechaUsuario(null);
				this.setTiempoUsuario(null);
				this.setFechaSistema(null);
				this.setTiempoUsuario(null);

				Log.e("NuevoProceso", "esta antes del hilo de msj exitoso");
				// mensaje de respuesta del servidor
				runOnUiThread(new Runnable() {
					public void run() {
						progressDialog.dismiss();
						// lo lleva a la vista inspeccion MP
						Intent intent = new Intent();
						intent.setClass(activity, InspaccionMp.class);
						Bundle b = new Bundle();
						b.putString("this", "NewProcess");
						intent.putExtra("llave", b);
						startActivity(intent);

						Log.e("NuevoProceso",
								"el servidor me retorna true y esta en el mensaje en pantalla");

					}
				});

			} else {
				runOnUiThread(new Runnable() {
					public void run() {

						progressDialog.dismiss();
						AlertDialog.Builder mensajeEmergente = new AlertDialog.Builder(
								activity);
						mensajeEmergente.setTitle(R.string.tituloError);
						mensajeEmergente
								.setMessage(R.string.msjERServerNoRetornaTrue);
						mensajeEmergente.setNeutralButton(R.string.btnAceptar,
								new DialogInterface.OnClickListener() {

									public void onClick(DialogInterface dialog,
											int which) {

									}
								});

						mensajeEmergente.create();
						mensajeEmergente.show();
						Log.e("NuevoProceso",
								"el servidor no retorna true y esta en el mensaje en pantalla");
					}
				});
			}

		} catch (Exception ex) {

			runOnUiThread(new Runnable() {
				public void run() {
					progressDialog.dismiss();
					manejadorMensajes.alertMessageOneButton(activity,
							R.string.tituloError, R.string.msjERConexionEnviar,
							R.string.btnAceptar);

					Log.e("NuevoProceso",
							"salto al catch de registrar nuevo proceso");

				}
			});
		}

	}

	@Override
	protected void onSaveInstanceState(Bundle outState) {
		super.onSaveInstanceState(outState);

		outState.putString("fecha", date);
		outState.putString("hora", time);

	}

	@Override
	protected void onRestoreInstanceState(Bundle savedInstanceState) {
		super.onRestoreInstanceState(savedInstanceState);

		this.setFechaUsuario(savedInstanceState.getString("fecha"));
		this.setTiempoUsuario(savedInstanceState.getString("hora"));

	}
}